import binarysearchtree.BinarySearchTree;

import java.util.*;

/**
 * @ClassName Test
 * @Description  Map & Set
 * @Author ZJX
 * @Date 2024/8/5 22:00
 * @Version 1.0
 */

//      Map：用于存储键值对关系，支持通过键快速查找对应值。
//      Set：用于存储唯一元素，确保数据无重复并支持集合操作。

public class Test {

    public static void main2(String[] args) {
        int[] array = {1, 2, 3, 3, 2}; // 初始化一个整数数组
        Map<Integer, Integer> map = new HashMap<>(); // 创建一个HashMap，用于存储数字及其对应的出现次数

        for (Integer x : array) { // 遍历数组中的每个元素
            if (map.get(x) == null) { // 如果map中没有这个数字，说明这是第一次遇到这个数字
                map.put(x, 1); // 将该数字作为键，出现次数设为1
            } else {
                int val = map.get(x); // 如果map中已经有这个数字，获取它当前的出现次数
                map.put(x, val + 1); // 将其出现次数加1，并更新到map中
            }
        }

        for (Map.Entry<Integer, Integer> entry : map.entrySet()) { // 遍历map中的每个键值对
            System.out.println("key: " + entry.getKey() + " val: " + entry.getValue()); // 输出每个数字及其对应的出现次数
        }
    }


    public static void main(String[] args) {
        Map<String,Integer> treeMap = new TreeMap<>(); //查找效率为 O(log N) 底层是红黑树

//        给map添加元素
        treeMap.put("the",3);
        treeMap.put("money",4);
        treeMap.put("hello",8);

//       get:  根据key 输出value
        System.out.println(treeMap.get("money"));

//        getOrDefault: 如果没有 将获取默认的value
        System.out.println(treeMap.getOrDefault("hello", 10));

//        返回所有 key 的不重复集合
        System.out.println(treeMap.keySet());

//        获取所有的 value
        System.out.println(treeMap.values());

//        返回所有的 key-value 映射关系 返回值为 Set K-V结构
        Set<Map.Entry<String, Integer>> entrySet = treeMap.entrySet();
        System.out.println("=========");
        for (Map.Entry<String, Integer> m :entrySet){
            System.out.println("key: "+m.getValue()+"  value: "+m.getKey());
        }

//        Set 使用学习
        Set<String> s = new TreeSet<>();

        s.add("orange");
        s.add("peach");
        s.add("banana");

//        // 获取集合的迭代器
        Iterator<String> it = s.iterator();
        while(it.hasNext()){
            System.out.println(it.next() + " ");
        }


        Map<String,Integer> hashMap = new HashMap<>(); //查找效率为 O(1)
    }


    /*
     * @param nums:
      * @return int
     * @author: ZJX
     * @description: 力扣 136 只出现一次的数字
     * @date: 2024/8/10 23:52
     */
    public int singleNumber(int[] nums) {
        HashSet<Integer> set = new HashSet<>(); // 哈希表
        for (int num : nums) {
            if(set.contains(num)){
                set.remove(num);
            } else{
                set.add(num);
            }
        }
        // 最后剩下的唯一元素就是只出现一次的数字
        return set.iterator().next();
    }


    /*
     * @param jewels:
    	 * @param stones:
      * @return int
     * @author: ZJX
     * @description: 力扣 771 宝石与石头
     * @date: 2024/8/10 23:55
     */
    public int numJewelsInStones(String jewels, String stones) {
//        用 HashSet 记录宝石种类
        HashSet<Character> hashSet = new HashSet<>();

        for (char c: jewels.toCharArray()){
            hashSet.add(c);
        }

        // 遍历所有石头，统计宝石数量
        int count = 0;
        for (char s:stones.toCharArray()){
            if (hashSet.contains(s)){
                count++;
            }
        }
        return count;
    }

    /*
     * @param words:
    	 * @param k:
      * @return java.util.List<java.lang.String>
     * @author: ZJX
     * @description: 力扣 692 前k个高频单词
     * @date: 2024/8/11 16:10
     */
    public List<String> topKFrequent(String[] words, int k) {
        return null;
    }

    public static void main1(String[] args) {
        BinarySearchTree binarySearchTree = new BinarySearchTree();
        int[] arr = {5,12,3,2,11,15};
        for (int i = 0; i < arr.length; i++) {
            binarySearchTree.insert(arr[i]);
        }
        System.out.println(binarySearchTree.search(3));
    }

}
